home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Franz PD / Franz PD Disk #324 (1994-04)(Rhein-Sieg-Soft).zip / Franz PD Disk #324 (1994-04)(Rhein-Sieg-Soft).adf / VideoText3.5 / source / jobs.p < prev    next >
Text File  |  1994-04-01  |  11KB  |  297 lines
  1. UNIT jobs; {$project vt }
  2. { Job-Verwaltung zum Programm VideoText }
  3.  
  4. INTERFACE; FROM vt USES global,sys,bildschirm,datei,cct,pagelist;
  5.  
  6. PROCEDURE sleep;
  7. PROCEDURE wakeup;
  8. PROCEDURE handle_queue;
  9. PROCEDURE handle_jobs;
  10. PROCEDURE attempt_input(job: Integer);
  11. PROCEDURE add_job(entry: Str80);
  12. PROCEDURE getconfig;
  13.  
  14. { ---------------------------------------------------------------------- }
  15.  
  16. IMPLEMENTATION;
  17. {$opt b-}
  18.  
  19. CONST SUBTITLE = $0040; { C6 }
  20.       SERMAG   = $0800; { C11 }
  21.  
  22. VAR bedtime: zeiteintrag;
  23.  
  24. PROCEDURE uhrzeit(VAR zeit: zeiteintrag);
  25. BEGIN
  26.   telltime(zeit.tage,zeit.min,zeit.tics);
  27. END;
  28.  
  29. PROCEDURE sleep;
  30. { wird vor Unterbrechung der Hauptschleife (z. B. durch Prozedur displayhelp) }
  31. { aufgerufen }
  32. BEGIN
  33.   uhrzeit(bedtime);
  34. END;
  35.  
  36. PROCEDURE wakeup;
  37. { Verhindert in Zusammenarbeit mit sleep, daß Zeiten, während derer der }
  38. { VT-Decoder gar nicht abgefragt wird, zum Löschen von Jobs wegen }
  39. { Zeitüberschreitung führen. }
  40. VAR delta: zeiteintrag;
  41.     j: Integer;
  42. BEGIN
  43.   uhrzeit(delta);
  44.   sub_time(bedtime,delta);
  45.   FOR j := 0 TO maxactive-1 DO
  46.     add_time(delta,activejobs[j].lastaction);
  47. END;
  48.  
  49. PROCEDURE handle_queue;
  50. { Wird aus der Hauptschleife heraus aufgerufen. Verwaltet das Aufrücken }
  51. { wartender Jobs und das Entfernen überalterter Seitenanforderungen. }
  52. { Ein Job besteht zunächst aus einer Seitennummer pg und einer Unterseiten- }
  53. { nummer sp, plus zusätzlichen Informationen, sobald er aktiv ist. }
  54. VAR i, j: Integer;
  55.     jetzt: zeiteintrag;
  56. BEGIN
  57.   { Prüfen, ob Jobs aus der Warteschlange in die aktiven Plätze nachrücken }
  58.   { können, erkennbar an 'aktiven' Jobs mit pg=0. }
  59.   FOR j := 0 to maxactive-1 DO
  60.     IF (activejobs[j].pg=0) AND (queued>0) THEN BEGIN
  61.       { freie Empfangseinheit mit wartendem Job belegen }
  62.       WITH activejobs[j] DO BEGIN
  63.         pg := queue[1].pg; sp := queue[1].sp;
  64.         sp_count := 0; sp_max := 0;
  65.         holen := False; erledigt := False; ist_UT := 0;
  66.         FOR i := 0 TO anzsubpage DO sp_check[i] := False;
  67.         uhrzeit(lastaction);
  68.         anfordern(j,pg,sp,'!!!');
  69.       END;
  70.       { Warteschlange aufrücken: }
  71.       Dec(queued);
  72.       FOR i := 1 TO queued DO  queue[i] := queue[i+1];
  73.       { Auswahlzeiger des Benutzers dem Aufrücken entsprechend nachführen: }
  74.       IF thisjob=-1 THEN thisjob := j
  75.         ELSE IF thisjob<0 THEN Inc(thisjob);
  76.       IF thisjob>=0 THEN BEGIN
  77.         aktspeicher := thisjob; display_select(aktspeicher); END;
  78.       redraw_queue(-1);
  79.     END;
  80.   { Prüfen, ob ein Job wegen Zeitüberschreitung gestrichen werden kann. }
  81.   { Wenn der Job allerdings so lange wartet, weil er sich auf eine einzelne }
  82.   { Unterseite bezieht, ist ihm verziehen und er wird lediglich ans Ende der }
  83.   { Warteschlange gesetzt. Und für Jobs, die sich auf Untertitel beziehen, }
  84.   { findet eine Prüfung auf Zeitüberschreitung gar nicht erst statt. }
  85.   uhrzeit(jetzt);
  86.   FOR j := 0 TO maxactive-1 DO WITH activejobs[j] DO
  87.     IF (pg<>0) AND (diff_time(lastaction,jetzt) > 50*maxwait)
  88.     AND (ist_UT=0) THEN
  89.       IF activejobs[j].sp = 0 THEN BEGIN   { einfache Seitennummer streichen }
  90.         activejobs[j].pg := 0;
  91.         sperren(j);
  92.         redraw_queue(j);
  93.       END ELSE                  { Unterseitenanforderung nur hintenanstellen }
  94.         IF queued>0 THEN BEGIN
  95.           IF queued<qlen THEN BEGIN
  96.             Inc(queued);
  97.             queue[queued].pg := activejobs[j].pg;
  98.             queue[queued].sp := activejobs[j].sp;
  99.           END;
  100.           activejobs[j].pg := 0;
  101.           sperren(j);
  102.           redraw_queue(-1);
  103.         END;
  104. END;
  105.  
  106. PROCEDURE handle_jobs;
  107. { Überprüft, ob in einem der Empfangskreise eine Seite eingetroffen ist, und }
  108. { wenn ja, ob sie aufgrund ihrer Unterseitennummer überhaupt eingelesen }
  109. { werden muß. Es wird auch entschieden, ob der Job durch die eingetroffene }
  110. { Seite erledigt ist. Einlesen der Seite geschieht an anderer Stelle, da nach }
  111. { Eintreffen der Kopfzeile erst eine Weile gewartet werden muß. }
  112. VAR j: Integer;
  113.     dummy: p_onepage;
  114. BEGIN
  115.   { Schauen, ob irgendwo das Eintreffen einer Kopfzeile gemeldet wurde: }
  116.   FOR j := 0 TO maxactive-1 DO WITH activejobs[j] DO
  117.     IF (pg>0) AND NOT holen THEN IF seite_da(j) THEN BEGIN
  118.       { write(#7); }
  119.       New(dummy);
  120.       uhrzeit(lastaction);
  121.       getpage(j,dummy,false); { *nur* Status und Seitennummer holen }
  122.       { *** Schauen, ob die Seite eingelesen werden muß. Gründe, weswegen }
  123.       {   man eine Seite evtl. nicht haben will: }
  124.       { 1.: Unterseite wurde bereits eingelesen. }
  125.       {   (Bei zu großen Unterseitennummern kann das nur über ein etwas }
  126.       {   armseliges Hilfskriterium festgestellt werden.) }
  127.       IF (dummy^.sp<=anzsubpage) THEN holen := NOT sp_check[dummy^.sp]
  128.         ELSE holen := (dummy^.sp>sp_max);
  129.       {   Und für UT-Seiten ist "bereits eingelesen" überhaupt kein }
  130.       {   Hinderungsgrund: }
  131.       IF ist_UT<>0 THEN holen := True;
  132.       { 2.: Nur eine Unterseite war angefordert, und zwar nicht diese. }
  133.       {   Das dürfte allerdings kaum vorkommen, da der CCT ausdrücklich auf }
  134.       {   die eine Unterseite programmiert wurde. }
  135.       IF (sp>0) THEN
  136.         holen := (dummy^.sp=sp)
  137.       { *** Unterseitenverwaltung aktualisieren: }
  138.       IF holen THEN BEGIN
  139.         Inc(sp_count);
  140.         IF (dummy^.sp<=anzsubpage) THEN  sp_check[dummy^.sp] := True;
  141.         IF dummy^.sp>sp_max  THEN sp_max := dummy^.sp;
  142.         akt_sp := dummy^.sp;
  143.         redraw_queue(j);
  144.       END;
  145.       { *** Prüfen, ob der Job durch die eingetroffene Seite erledigt ist. }
  146.       {   Das geht z. B. durch Unterseite 0 (= einzige Unterseite), auf }
  147.       {   keinen Fall aber durch eine Unterseite mit der bislang höchsten }
  148.       {   Nummer. }
  149.       IF sp_check[0] THEN
  150.         erledigt := sp_count>sp_max
  151.       ELSE IF dummy^.sp<sp_max THEN
  152.         erledigt := sp_count=sp_max;
  153.       { Auch möglich: die einzig geforderte Unterseite ist da. }
  154.       IF (sp>0) AND holen THEN
  155.         erledigt := True;
  156.       { *** Schauen, ob magazinserielle oder -gemischte Übertragung vorliegt }
  157.       {   und danach die Wartezeit festlegen: }
  158.       IF (dummy^.cbits AND SERMAG)=0 THEN
  159.         wartezeit := shuffle ELSE wartezeit := burst;
  160.       IF NOT holen THEN
  161.         anfordern(j,pg,sp,'!!!');   { Suche geht weiter, PBLF setzen }
  162.       Dispose(dummy);
  163.     END;
  164. END;
  165.  
  166. PROCEDURE attempt_input{(job: Integer)};
  167. { Das Einlesen geschieht in einem zweiten Schritt, da nach Eintreffen der }
  168. { Kopfzeile erst eine Weile gewartet werden muß. Evtl. wird die Seite auch }
  169. { gleich ausgegeben: auf dem Bildschirm, falls <thisjob> auf den zugehörigen }
  170. { Job zeigt; in die Protokolldatei, falls es eine Untertitelseite ist und }
  171. { Protokollierung erwünscht war. }
  172. { Erledigte Jobs werden auch gestrichen, sobald keine zu holende Seite mehr }
  173. { aussteht. }
  174. { Kriterium für 'erledigt': }
  175. { Ein Job mit sp<>0 ist erledigt, sobald die eine angeforderte Unterseite }
  176. { da ist. Ein Job mit sp=0 ist erst dann erledigt, wenn alle seine }
  177. { Unterseiten eingelesen wurden. Ein Job, der sich auf eine Untertitelseite }
  178. { bezieht (Flag C5), ist niemals erledigt und muß anderweitig entfernt }
  179. { werden. }
  180. VAR dummy,seite: p_onepage;
  181.     jetzt: zeiteintrag;
  182. BEGIN
  183.   { Prüfen, ob die Wartezeit für eine einzulesende Seite um ist: }
  184.   WITH activejobs[job] DO
  185.     IF (pg>0) AND holen THEN BEGIN
  186.       uhrzeit(jetzt);
  187.       IF diff_time(lastaction,jetzt) >= wartezeit THEN BEGIN
  188.         { Seite einlesen: }
  189.         busy_pointer;
  190.         { Ist bereits eine alte Version dieser Seite in der Liste, die dann }
  191.         { lediglich überschrieben werden müßte? }
  192.         seite := hunt_in_list(pg,akt_sp,True);
  193.         IF seite=Nil THEN BEGIN
  194.           New(seite);
  195.           getpage(job,seite,True);
  196.           ins_to_list(seite);
  197.           normal_pointer;
  198.           redraw_list;
  199.         END ELSE BEGIN
  200.           getpage(job,seite,True);
  201.           normal_pointer;
  202.         END;
  203.         IF seite=thispage THEN  writepage(seite,True);
  204.         { notieren, ob das eine Untertitelseite war: }
  205.         ist_UT := ist_UT SHR 1; { Bits altern lassen }
  206.         IF (seite^.cbits AND SUBTITLE)<>0 THEN ist_UT := ist_UT OR $04;
  207.         IF protokoll AND (ist_UT<>0) THEN BEGIN
  208.           mainline;
  209.           Write('Untertitelseite ',seite^.pg,' ...');
  210.           IF savebox(seite,outputname,True) THEN
  211.             Write(' gespeichert.')
  212.           ELSE BEGIN
  213.             mainline; Write(#155'33mDateifehler - sorry!');
  214.           END;
  215.         END;
  216.         holen := False;  { Wichtig !!! }
  217.         anfordern(job,pg,sp,'!!!');   { um PBLF wieder zu setzen }
  218.       END;
  219.     END;
  220.   { Erledigten Job löschen, außer er bezieht sich auf Untertitel }
  221.   WITH activejobs[job] DO
  222.     IF (pg>0) AND erledigt AND NOT holen THEN
  223.       IF (ist_UT<>0) THEN BEGIN   { nicht löschen }
  224.         sp_check[0] := False; sp_count := 0; redraw_queue(job);
  225.       END ELSE BEGIN  { löschen }
  226.         pg := 0; redraw_queue(job); sperren(job);
  227.       END;
  228. END;
  229.  
  230. PROCEDURE add_job{(entry: Str80)};
  231. { Eine Eingabe, die eine Seitennummer darstellt (oder auch nicht), in die }
  232. { Warteschlange einzureihen versuchen. }
  233. var j,ok,page,subpage: integer;
  234.     s: str80;
  235. begin
  236.   j := pos('/',entry);
  237.   if j > 0 then begin
  238.     s := copy(entry,1,j-1);
  239.     val(s,page,ok);
  240.     s := copy(entry,j+1,length(entry)-j);
  241.     val(s,subpage,ok);
  242.   end else begin
  243.     val(entry,page,ok);
  244.     subpage := 0;
  245.   end;
  246.   if (ok=0) AND (page>=100) AND (page<900) AND (queued<qlen) then begin
  247.     Inc(queued);
  248.     queue[queued].pg := page; queue[queued].sp := subpage;
  249.   end;
  250. end;
  251.  
  252. PROCEDURE getconfig;
  253. VAR datei: text;
  254.     sender, zeile: Str80;
  255.     is_job, found, anything: boolean;
  256.     t: integer;
  257. BEGIN
  258.   anfordern(0,100,0,'***');
  259.   t := 50;   { max. 1 sec warten! }
  260.   REPEAT Delay(1); Dec(t) UNTIL seite_da(0) or (t=0);
  261.   gethead(0,sender);
  262.   WITH activejobs[0] DO
  263.     IF pg>0 THEN  anfordern(0,pg,sp,'!!!')  ELSE  sperren(0);
  264.   Reset(datei,'VT.config');
  265.   IF IOResult<>0 THEN BEGIN
  266.     Reset(datei,'s:VT.config');
  267.     IF IOResult<>0 THEN BEGIN
  268.       Write(#155'33m"VT.config" nicht gefunden!');
  269.       Exit;
  270.     END;
  271.   END;
  272.   found := False; anything := False;
  273.   WHILE NOT EoF(datei) DO BEGIN
  274.     ReadLn(datei,zeile);
  275.     is_job := True;
  276.     FOR t := 1 TO Length(zeile) DO
  277.       IF NOT (zeile[t] IN ['0'..'9','/']) THEN is_job := False;
  278.     IF is_job THEN BEGIN
  279.       IF found THEN add_job(zeile);
  280.       IF queued=maxactive THEN handle_queue;   { Jobs evtl. aufrücken }
  281.     END ELSE BEGIN
  282.       found := (Pos(zeile,sender)>0) AND (zeile<>'');
  283.       IF found THEN BEGIN
  284.         mainline; Write('hole Seitenauswahl f}r "',zeile,'"');
  285.         anything := true;
  286.       END;
  287.     END;
  288.   END;
  289.   IF NOT anything THEN Write('unbekannter Sender: "',Copy(sender,5,10),'"');
  290.   Close(datei);
  291.   redraw_queue(-1);
  292. END;
  293.  
  294. BEGIN  { Initialisierungen }
  295. END.
  296.  
  297.